CD Actual 1/PC Actual CD 01.iso/trucos/utils/util.wri

Text File | 1995-02-10 | 38.5 KB | 2,191 lines

UTILIDADES

CARGADOR DE EJECUTABLES

Esta rutina no es mßs que un cargador/reubicador de ficheros EXE. Los
creadores del DOS no debieron pensar en su dφa que en ciertas
ocasiones la carga de ficheros EXE mediante funciones del sistema no
se ajusta a las necesidades de ciertas aplicaciones, como por ejemplo
aquellas que requieran cargar un fichero EXE desde dentro de otro
fichero.

Esta rutina subsana este problema, ya que permite cargar ficheros y
especificar en que offset dentro de Θstos se encuentra el EXE (para
una carga normal de ficheros EXE se usa un offset de 0 y ya estß). No
puede cargar ficheros con overlays ni ficheros COM, y aunque no
funciona en el 100% de los casos, su efectividad es bastante alta.

Las rutinas son para Turbo Pascal 7.0. Se compila primero la unidad
½Exec╗ y despuΘs el fichero ½Exectest╗. Su uso es sencillo:

EXECTEST fichero.exe

La unidad ½exec╗ es la que sigue:

UNIT Exec;

INTERFACE

USES

 Dos;

VAR

 FicheroExe : STRING;

 header: ARRAY [1..28] OF BYTE;

 handle,PSPSegment,StartSegment:WORD;

 item: ARRAY [1..2] OF WORD;

 memory,imagesize:WORD;

PROCEDURE ExecFile(pos:LONGINT);


IMPLEMENTATION

{ convierte un string en formato ASCIIZ para utilizarlo con }

{ las funciones del DOS }

PROCEDURE StringToAsciiz; ASSEMBLER;

ASM

 mov bx,OFFSET FicheroExe

 xor cx,cx

 mov cl,[bx]

@@StringToASCII:

 mov al,[bx+1]

 mov [bx],al

 inc bx

 loop @@StringToASCII

 mov byte ptr [bx],0

END;

{ Carga, reubica y ejecuta un fichero .EXE }

PROCEDURE ExecFile(pos:LONGINT); ASSEMBLER;

ASM

 push es

 call StringToAsciiz { convierte el nombre del .exe a ASCIIZ }

 push ds

 mov ax,3d00h

 mov dx,OFFSET FicheroExe

 int 21h { abre el fichero para s≤lo lectura }

 { indexado del fichero }

 push ax

 mov bx,ax { handle del fichero }

 mov ax,04200h

 mov dx,word ptr [pos]

 mov cx,word ptr [pos+2]

 int 21h

 pop ax

 mov [handle],ax { guarda el handle del fichero }

 mov bx,[handle]

 mov dx,OFFSET header { cabecera del fichero .exe }

 mov cx,28

 mov ah,3fh

 int 21h { lee los 28 bytes estßndar de la cabecera }

 pop ds

 mov bx,OFFSET header

 mov cx,[bx+08h] { longitud del header en parßgrafos }

 mov ax,16

 imul cx { DX:AX -> posici≤n de inicio de m≤dulo }

 mov cx,dx

 mov dx,ax { CX:DX -> posici≤n para el LSEEK }

 add dx,word ptr [pos]

 adc cx,word ptr [pos+2]

 mov bx,[handle]

 xor al,al

 mov ah,42h

 int 21h

{ posiciona el puntero del fichero al inicio del m≤dulo del programa }

 mov bx,OFFSET header

 mov ax,[bx+4] { longitud total incluyendo la cabecera }

 inc ax { 1+ por si acaso }

 mov cx,32

 mul cx { parßgrafos totales }

 mov [imagesize],ax { tama±o del modulo del programa }

 mov bx,0ffffh

 mov ah,48h

 int 21h

 jnc @@no_error0

 mov [memory],bx

 mov ah,48h

 int 21h { con esto reservamos el mßximo de memoria }

@no_error0:

 mov [PSPSegment],ax

 { genera un nuevo PSP...UNDOCUMENTED! }

 push ax

 mov dx,ax

 mov ah,055h

 mov si,dx

 add si,10h

 add si,[memory]

 { valor a escribir en el campo de memoria del PSP }

 int 21h

 pop ax

 mov es,ax

 xor di,di

 mov word ptr es:[di+0ah],OFFSET @@retorna

 mov es:[di+0ch],cs

 add ax,16

 mov [StartSegment],ax

 { aquφ nos encargamos de leer el m≤dulo principal del programa, que }

 { no es mßs que el c≤digo y los datos en sφ... }

 mov bx,[handle]

 mov cx,[imagesize]

 push ds

 mov ds,[StartSegment]

@@next_block:

 push cx

 xor dx,dx

 mov cx,16 { 16 bytes cada bloque }

 mov ah,3fh

 xor al,al

 int 21h

 jc @@END_read

 mov ax,ds

 inc ax

 mov ds,ax

 pop cx

 loop @@next_block

 pop ds

 jmp @@readgood

@@END_read:

 pop cx

 pop ds

@@readgood:

 { ahora posiciona el puntero del fichero al inicio de la tabla de }

 { reubicaci≤n del fichero .EXE }

 mov si,OFFSET header

 mov ax,[si+18h]

 { offset en bytes en el fichero de la tabla de reubicaci≤n del .exe }

 mov dx,ax

 xor cx,cx

 add dx,word ptr [pos] { mßs la posici≤n }

 adc cx,word ptr [pos+2]

 mov bx,[handle]

 mov ah,42h

 xor al,al

 int 21h

 { ahora comienza la reubicaci≤n de verdad del fichero }

 mov si,OFFSET header

 mov cx,[si+06h] { n·mero de datos de items de la tabla de reubicaci≤n }

 test cx,0ffffh

 jz @@no_realocate

@@siguiente_item:

 push cx

 mov dx,OFFSET item

 mov bx,[handle]

 mov cx,4 { cada item se compone de offset:segmento -> 4 bytes }

 mov ah,3fh

 int 21h

 mov bx,OFFSET item

 mov ax,[StartSegment]

 { a cada posici≤n indicada por el item se

 le suma el segmento de inicio del m≤dulo }

 add ax,[bx+2]

 mov di,[bx]

 mov es,ax

 mov ax,es:[di]

 add ax,[StartSegment]

 mov es:[di],ax

 pop cx

 loop @@siguiente_item

@@no_realocate:

 mov bx,[handle]

 mov ah,3eh

 int 21h { cierra el fichero }

 { set new PSP address...UNDOCUMENTED! }

 mov bx,[PSPSegment]

 mov ah,50h

 int 21h

 mov bx,OFFSET @@oldss

 cli

 mov cs:[bx],ss

 mov cs:[bx+2],sp

 mov cs:[bx+4],bp

 sti

 mov bx,OFFSET header

 mov ax,[bx+0eh]

 add ax,[StartSegment]

 cli

 mov ss,ax

 mov sp,[bx+10h] { genera SS:SP a partir del header }

 sti

 mov ax,[bx+14h]

 mov dx,[bx+16h]

 add dx,[StartSegment] { DX:AX -> CS:IP }

 push dx

 push ax

 mov es,[PSPSegment]

 mov ds,[PSPSegment]

 xor ax,ax { borra todos los registros }

 mov di,ax

 mov si,ax

 mov bx,ax

 mov cx,ax

 mov dx,ax

 mov bp,ax

 retf

@@retorna:

 mov bx,OFFSET @@oldss

 cli

 mov ss,cs:[bx] { recupera todos los registros }

 mov sp,cs:[bx+2]

 mov bp,cs:[bx+4]

 sti

 mov ax,SEG @data

 mov ds,ax

 mov es,[PSPSegment]

 mov ah,49h

 int 21h { libera la memoria guardada por el }

 jmp @@restore

@@oldss: dw 0

@@oldsp: dw 0

@@oldbp: dw 0

@@restore:

 pop es

END;

BEGIN

END.


El programa ½Exectest╗ es el sigiente:


{$M,16000,0,0}

{$F+}

USES Dos, Crt, Exec;

{ devuelve la memoria que queda libre }

FUNCTION MemoriaLibre: WORD; ASSEMBLER;

ASM

 mov bx,0ffffh

 mov ah,48h

 int 21h

 mov ax,bx

END;

{ programa principal }

BEGIN

 WriteLn('Exec loader version 2.11');

 IF paramcount=0 THEN

 BEGIN

 WriteLn('Usage <filename.exe>');

 Halt;

 END;

 Write('Memoria libre antes de ejecutar el programa:
 ',LongInt(MemoriaLibre)*16,' bytes');

 FicheroExe:=paramstr(1);

 ExecFile(0);

 ASM

 mov ax,03

 int $10

 END;

 Write('Memoria libre despuΘs de salir del programa:
 ',LongInt(MemoriaLibre)*16,' bytes');

END.

JosΘ Cabezas Garcφa

Barcelona


ACTUALIZACION DEL PATH

El siguiente programa tiene como finalidad el a±adir o actualizar
directorios en la variable de entorno ½Path╗ de forma temporal, es
decir, hasta que se apague el ordenador, o bien de forma definitiva
a±adiΘndolo automßticamente en el ½autoexec.bat╗.

Para a±adir directorios de forma temporal basta con pasarle como
parßmetros los directorios a a±adir separados por espacios o por punto
y coma (;). Si queremos que los cambios sean permanentes, esto es,
que se actualice el ½autoexec.bat╗, basta con poner el modificador /A
al final del comando, justo despuΘs de los nuevos directorios que
queremos a±adir.

@Echo off

if "%1"=="" goto sin_args

:loop

if "%1"=="" goto fin_ok

if "%1"=="/A" goto permanente

if "%1"=="/a" goto permanente

set path=%path%;%1

shift

goto loop

:permanente

echo set path=%path% >> c:\autoexec.bat

goto fin

:sin_args

echo Sintaxis: MPATH camino [camino] ...

echo Para modificar AUTOEXEC.BAT: MPATH camino [camino] ... /A

goto final

:fin_ok

echo Nuevo PATH=%Path%

:final

Luis Rodrφguez Beteta

Madrid



CAPTURADOR DE PANTALLAS ASCII

El siguiente truco, realizado con Turbo Pascal, es un capturador de
pantallas ASCII que ocupa menos de 10 Kbytes de memoria y cuyo
funcionamiento se basa en que cuando se instala en memoria captura la
interrupci≤n del teclado.

Para capturar una pantalla basta con pulsar la combinaci≤n ½Shift-F2╗,
lo que darß lugar a que el programa genere un archivo llamado
½Capt-XX.txt╗, donde XX es sustituido por un 00, 01, 02... que
equivale al n·mero de pantalla capturada.

{$M 2000, 0, 0}

{$R-, S-, I-, D+, F+,V-, V-, B-, N-, L-}

Program Capturador;

Uses Dos;

Const IntTec = $09;

Type Matriz = Array [1..2000] Of Byte;

Var

 VecTecAnt : Pointer;

 Buffer : Matriz;

 Archivo : File Of Matriz;

 XW1, XW2, XW3 : Word;

 XS1 : Strig;

Procedure CapturaPantalla;

Begin

 If Mem[Seg0040:$0049]=7 Then XW1:=$B000 Else XW1:=$B800;

 XW3:=1;

 For XW2:=0 To 3999 Do

 Begin

 Buffer[XW3]:=Mem[XW1:XW2];

 Inc(XW2);

 Inc(XW3);

 End;

 XW1:=0;

 Repeat

 Str(Xw1:2,XS1);

 If XS1[1]=#32 Then XS1[1]:='0';

 XS1:='CAPT-'+XS1+'.TXT';

 Assign (Archivo,XS1);

 Reset(Archivo);

 If IOResult = 0 The Close(Archivo)

 Else

 Begin

 Rewrite(Archivo);

 Write(Archivo, Buffer);

 Close(archivo);

 Exit;

 End;

 Inc(XW1);

 Until False;

End;

Procedure Teclado (Flags, CS, IP, AX, BX, CX, DX, SI, DI, DS, ES,
BP:Word); Interrupt;

Begin

 Asm

 pushf

 call VecTecAnt

 End;

 If Port[96]=60 Then CapturaPantalla;

 Inline($FB);

End;

Begin

 WriteLn('Capturador de pantallas ASCII');

 WriteLn('Para capturar la pantalla pulsar Shift-F2');

 GetIntVec(IntTec,VecTecAnt);

 SetIntVec(IntTec,@Teclado);

 Keep(0);

End.

Bernardo Calero Castellano

Tomelloso (Ciudad Real)

Nota del Laboratorio: La idea de esta utilidad consiste en visualizar
un cursor en pantalla y que podamos moverlo y situarlo donde queramos.
En este punto apretaremos ½ENTER╗ y podremos seguir moviendo el cursor
para se±alar los dos vΘrtices de la zona a capturar. Una vez elegida
la zona bastarß grabar el contenido de las posiciones de memoria que
se encuentran entre los dos vΘrtices.


MENSAJES POR VOZ

Muchas veces resulta interesante dejar una nota a la siguiente persona
que va a utilizar el ordenador, o simplemente un recordatorio para
nosotros mismos. Sin embargo, lo ideal serφa poder dejar un mensaje
de viva voz. Pues bien, eso es lo que hace el programa
½mensajes.bat╗.

Para su correcto funcionamiento es imprescindible que se cumplan los
siguientes requisitos:

1. El programa estß ideado, en principio, para los poseedores de una
tarjeta de sonido Sound Blaster, aunque tambiΘn se pueden dejar
mensajes por escrito.

2. Requiere la versi≤n 6.0 ≤ posteri≤r de MS-DOS (ya que utiliza el
comando CHOICE).

3. Se debe instalar el controlador ½ANSI.SYS╗ (o en caso contrario
habrß que suprimir las secuencias de escape, ya que s≤lo sirven para
cambiar el color de la pantalla).

4. Los programas ½VPLAY╗ y ½VREC╗ de la Sond Blaster deben estar
disponibles mediante la variable de entorno PATH. (TambiΘn se puede
especificar la ruta de acceso cada vez que aparezca una llamada a
cualquiera de estos dos programas)

5. El programa debe ser instalado en un subdirectorio llamado
½mensajes╗.

Si ejecutamos la aplicaci≤n desde la lφnea de comandos se nos
presentarß un men· desde el que podremos grabar mensajes escritos o
hablados, escuchar el mensaje pregrabado o borrar el mensaje
almacenado.

Si arrancamos la utilidad con la opci≤n r (½mensajes r╗) o incluyendo
la llamada ½call c:\mensajes\mensajes.bat r╗ en el ½autoexec.bat╗, nos
recordarß los mensajes hablados y/o escritos (si es que existen) y
despuΘs nos darß la oportunidad de volver a escucharlos o borrarlos.
En caso de que no exista ning·n mensaje esta llamada no tiene ning·n
efecto.

@echo off

if "%1" =="r" goto principio

if "%1" =="R" goto principio

:principal

rem ** Rutina principal **

rem **********************

echo

cls

echo  MENSAJES.BAT

echo.

echo OPCIONES

echo.

echo [1] Grabar mensaje de texto

echo [2] Grabar mensaje de voz

echo.

echo [3] Escuchar mensaje

echo.

echo [4] Borrar mensaje

echo.

echo [0] SALIR

echo.

choice Opci≤n /c:01234

if errorlevel 5 goto borra

if errorlevel 4 goto principio

if errorlevel 3 goto grabavoz

if errorlevel 2 goto grabatexto

if errorlevel 1 goto end

:Grabavoz

cls

vrec mensaje /s:11000

goto principal

:Grabatexto

edit mensaje.txt

goto principal

rem ** Rutina que recuerda los mensajes y sale del programa **

rem **********************************************************

:principio

if exist c:\mensajes\mensaje.* goto rutina

echo MENSAJES.BAT: No hay mensajes para usted

echo.

if "%1" =="r" goto End

if "%1" =="R" goto End

goto principal

:rutina

echo

cls

echo  MENSAJES.BAT

echo Hay un mensaje para usted:

echo.

if not exist c:\mensajes\mensaje.txt goto voz

type c:\mensajes\mensaje.txt|more

:voz

echo

if exist c:\mensajes\mensaje.voc vplay c:\mensajes\mensaje>nul

if exist c:\mensajes\mensaje.voc choice ┐Desea que le repita el
mensaje

if not exist c:\mensajes\mensaje.voc pause

if errorlevel 2 goto sigue

if errorlevel 1 goto principio

:sigue

choice ┐Borrar mensaje

if errorlevel 2 goto continua

if errorlevel 1 goto borra

:Borra

echo Borrando mensaje... Espere por favor

del c:\mensajes\mensaje.txt>nul

del c:\mensajes\mensaje.voc>nul

if "%1" =="r" goto continua

if "%1" =="R" goto continua

goto principal

:continua

if "%1" =="r" goto End

if "%1" =="R" goto End

goto principal

:end

echo

cls

Gorka Elexgaray

Guernica. (Vizcaya)


PARTICION DE FICHEROS

En muchas ocasiones nos encontramos ante un fichero de texto cuyas
dimensiones hacen imposible que sea editado. Mediante esta utilidad
escrita en Turbo Pascal, podremos dividir cualquier fichero en
diversos ficheros del numero de lφneas que deseemos. Por defecto se
toma el n·mero de 5.000 lφneas por fichero.

{$i-}

Program Partidor;

Var

 Origen,

 Final :Text;

 No_de_lineas,

 Actual :LongInt;

 FichF :String[5];

 NoArch,

 Codigo :Integer;

 Item :String;

 No_fichero :Byte;

Begin

 No_de_lineas:=5000;

 If ParamCount>2 then Val(ParamStr(3), No_de_Lineas, Codigo);

 If (ParamCount<2) Or (Codigo<>0) then

 begin

 WriteLn('Usar: [unidad:][camino\]Partidor [unidad:]'+

 '[camino\]Arch_Original.ext Arch_final');

 Halt;

 End;

 FichF:=Copy(ParamStr(2),1,5);

 If No_de_lineas<512 then No_de_lineas:=512;

 Assign(Origen,ParamStr(1));

 Reset(Origen);

 If IOResult<>0 then

 begin

 WriteLn('Imposible abrir ',ParamStr(1));

 Halt(1);

 End;

 WriteLn('Fragmentando '+ParamStr(1)+'...');

 No_Fichero:=0;

 Repeat;

 Actual:=0;

 Inc(No_Fichero);

 Str(No_Fichero,Item);

 While Length(item)<3 do

 Item:='0'+Item;

 Assign(Final,ParamStr(2)+'.'+Item);

 Rewrite(Final);

 If IOResult<>0 then

 begin

 WriteLn('Imposible crear '+ParamStr(2)+'.'+Item);

 Halt(1);

 End;

 While Not Eof(Origen) do

 begin

 ReadLn(Origen,Item);

 WriteLn(Final,Item);

 Inc(Actual);

 If Actual=No_de_lineas then break;

 End;

 Close(Final);

 Until Eof(Origen);

 Close(Origen);

 WriteLn('Archivo '+ParamStr(1)+' fragmentado en ',No_Fichero,'Archivos.');

End.

Los consejos del Laboratorio:

- Como ya hemos comentado, la utilidad de este programa radica en
poder dividir ficheros de texto que a causa de su tama±o no son
editables, en otros de menor tama±o. Una vez que hemos realizado los
cambios deseados sobre cada unos de los ficheros mßs peque±os, puede
que nos interese volver a juntar dichos archivos para tener de nuevo
un ·nico fichero. Para juntar todos los ficheros podemos recurrir a
la orden ½copy╗ del DOS, de la siguiente forma: ½copy
fich1+fich2+...+fichn fichfin╗

Luciano Rubio

Madrid


PARTICION DE FICHEROS MEJORADA

En el truco anterior hablßbamos de una utilidad que servφa para
descomponer ficheros de texto en otros de menor tama±o, para de esta
forma poder ser editados con facilidad. Esta nueva utilidad, aunque
bßsicamente hace lo mismo, tiene la ventaja de poder utilizarse tanto
con ficheros de texto como en ficheros binarios.

Su utilidad es clara, si tenemos un ejecutable que sobrepase la
capacidad de nuestros disquetes, podemos dividirlo en diferentes
ficheros binarios los cuales puedan ser grabados en disquetes, para
luego resconstruirlos a su formato original.

La sintaxis de uso la indica el propio programa, asφ como el tama±o y
numero de ficheros creados. De igual forma, indica como regenerar el
fichero original a partir de los trozos.

program trocear;

 uses dos,crt;

var

 fuente,destino:file of byte;

 i,veces,e:integer;

 tamano,c,tamanototal,j:longint;

 b:string[10];

 nombre,nombreb,nombreorigen:string[9];

 extension:string[3];

 letra:byte;

 fin:boolean;

begin

 fin:=false;

 if paramstr(1)='' then

 begin

 writeln('troceador por ram≤n bernardo 93');

 writeln;

 writeln('sintaxis: trocear fichero.ext tama╤o');

 writeln;

 writeln('donde tama±o estß entre 1024 y 2147483647 bytes');

 writeln;

 writeln('por defecto el tama±o es de 360 kb');

 halt(1);

 end

 else

 begin

 {$i+}

 nombreorigen:=paramstr(1);

 if paramstr(2)='' then b:='367616'

 else b:=paramstr(2);

 val(b,tamano,e);

 if tamano<1024 then

 begin

 writeln('error:el tama±o de los subficheros ha de ser mayor de 1024');

 halt(1);

 end;

 tamano:=1024*(tamano div 1024);

 assign(fuente,paramstr(1));

 reset(fuente);

 nombreb:='';

 nombre:='';

 for j:=1 to length(nombreorigen) do

 if nombreorigen[j]='.' then j:=length(nombreorigen)

 else nombreb:=concat(nombreb,nombreorigen[j]);

 veces:=0;

 repeat

 str(veces,extension);

 repeat

 extension:=concat('0',extension);

 until length(extension)=3;

 nombre:=concat(nombreb,'.',extension);

 write('creando el fichero ',nombre);

 c:=0;

 assign(destino,nombre);

 rewrite(destino);

 while (not eof(fuente) and (c < tamano)) do

 begin

 read(fuente,letra);

 write(destino,letra);

 c:=c+1;

 end;

 writeln(' ',c,' bytes');

 if eof(fuente) then fin:=true;

 close(destino);

 veces:=veces+1;

 c:=0;

 until fin;

 close(fuente);

 writeln;

 writeln;

 writeln('para regenerar el fichero original teclear :');

 writeln;

 writeln('si el fichero original es ascii (texto)');

 writeln('copy ',nombreb,'.000+',nombreb,'.001+',nombreb,'.002+... ',nombreb,'.extension');

 writeln;

 writeln('si el fichero original es binario (exe,com,..)');

 writeln('copy ',nombreb,'.000 /b+',nombreb,'.001 /b+',nombreb,'.002 /b+... ',nombreb,'.extension');

 end;

 {$i-}

end.

Ram≤n B. de Bernardo Hernßn

Sestao. Vizcaya


ORDENADOR PROTEGIDO

Mßs de una vez se habrß ausentado del ordenador durante unos minutos y
habrß querido bloquearlo para que nadie pudiera fisgar en Θl. O quizß
en alg·n momento dese≤ que desapareciera el contenido de la pantalla y
retornar a ella en cualquier momento. Este peque±o programa en C le
propone una soluci≤n.

Es una aplicaci≤n residente que se activa al pulsar una tecla o
combinaci≤n de ellas, salvando el contenido de la pantalla (modo
texto), borrandola y bloqueando el teclado. No se recuperarß la
pantalla inicial hasta que se pulsa la combinaci≤n de teclas elegida.
La rutina s≤lo se instala una vez, ya que si se vuelve a hacer es
ignorada.

Las teclas que se usan para activarlo son Ctrl+Shift (izquierda) y
para desactivarlo Alt+F1. Estas teclas pueden ser otras, a gusto del
usuario, con el ·nico problema de conocer el c≤digo correspondiente.
Para detectar la pulsaci≤n de Ctrl+Shift (izq) se busc≤ en el ßrea de
comunicaciones de la BIOS en la direcci≤n 0040:0017h (1 byte). Para
Alt+F1 se ha usado la interrupci≤n 16h de la BIOS, comprobando el
c≤digo de exploraci≤n y el c≤digo ASCII correspondiente (si existe).
Si el c≤digo ASCII no existe (es cero), se examina el c≤digo de
exploraci≤n.

En el caso de las teclas Alt+F1 el c≤digo ASCII correspondiente es 00,
mientras que el c≤digo de exploraci≤n es 68h.

#include <Dos.h>

#include <Bios.h>

#include <Stdio.h>

unsigned int far *mem;

void interrupt ( *oldhandler)();

/* Funci≤n a la que se asigna la interrupci≤n 9, que es la que
intercepta*/

void interrupt handler()

/* Funci≤n que reemplaza a la interrupci≤n 9*/

{

 char ah, p_activa;

 static char activo = 0; /* Variable semßforo */

 enable(); /*Habilitar interrupciones hardware */

 oldhandler();

 if ((peekb(0x40,0x17) & 6)==6 && activo==0)

 /*Crtl+Shift(Izq) Pulsadas*/

 {

 activo = 1;

 /* Si volvemos a pulsar Crtl+Shtf(Izq) no tendrß efecto */

 _AH=0xf; /* Se obtiene la pßgina de visualizaci≤n activa */

 geninterrupt (0x10);

 p_activa=_BH;

 _AH=0x5; /* Se cambia de pßgina activa */

 _AL=p_activa+3;

 geninterrupt (0x10);

 do

 {

 _AH=0; /* Se espera pulsaci≤n de tecla */

 geninterrupt (0x16);

 ah=_AH; /* Almacena c≤digo de exploraci≤n */

 }

 while(ah != 0x68); /* Mientras que no se pulse Alt+F1 */

 _AH=0x5; /* Se reestablece la pßgina activa inicial */

 _AL=p_activa;

 geninterrupt (0x10);

 activo=0;

 }

}

void main()

{

 /* Se comprueba que la rutina s≤lo se instale una vez */

 if( (FP_OFF(getvect(0x9))) != (FP_OFF(handler)) )

 {

 oldhandler=getvect(0x9);

 /* Guarda la direcci≤n de la interrupci≤n 9 que estß en la tabla de
 vectores de int */

 setvect(0x9,handler);

 /* Asigna la direcci≤n de nuestra rutina al vector de interrupci≤n
 de la int 9 */

 printf("*** Rutina instalada *** ");

 mem=MK_FP(_psp,0x2c);

 _AX=4900;

 _ES=*mem;

 geninterrupt(0x21); /*Elimina el bloque de entorno */

 keep(0,_SS + (_SP/16) - _PSP); /* Deja el programa residente */

 }

}

Los consejos del Laboratorio:

- Una forma de mejorar esta aplicaci≤n es introduciendo un peque±o
programa de configuraci≤n, de forma que al instalarse se pueda
modificar directamente las teclas que lo activan y lo desactivan.

- TambiΘn se le puede meter una rutina para que acepte un
parßmetro que haga que el programa se desinstale de la memoria.

Oscar Bernal Gonzßlez

Valladolid


LA LUZ DEL DISCO DURO

Mediante la siguiente rutina (escrita es Turbo Pascal 6.0) podemos
simular en pantalla el led de estado del disco duro. Esta simulaci≤n
puede representar grandes ventajas para aquellos usuarios que no
pueden visualizar dicho led, por tener la cpu debajo de la mesa, por
ejemplo.

program disklighter_v4;

{$m 1024,0,0}

(* reserva 1k para stack. *)

uses dos,crt;

type rutina_tratamiento=procedure;

const

 tiempo = 50;

var

 rutina_original :rutina_tratamiento;

 interrup_hd :byte;

 puntero,vector :pointer;

procedure nueva_rutina; interrupt;

var
 i :integer;

begin

 for i:=0 to tiempo do

 (* tiempo de luz. *)

 begin

 mem[$b800:156]:=ord('h');

 (* acceso a memoria de video. *)

 mem[$b800:157]:=$21;

 mem[$b800:158]:=ord('d');

 mem[$b800:159]:=$21;

 end;

 mem[$b800:157]:=$00;

 mem[$b800:159]:=$00;

 rutina_original;

end;

(* programa principal *)

begin

 writeln;

 writeln('disklighter v4.0 residente en memoria.');

 interrup_hd:=$76;

 getintvec(interrup_hd,vector);

 @rutina_original:=vector;

 setintvec(interrup_hd,@nueva_rutina);

 keep($00);

end.

Esta rutina intercepta la interrupci≤n que actua sobre el contador de
interrupciones 8259, la cual se genera cada vez que se accede al disco
duro, y redirecciona el vector que apunta a la rutina de tratamiento
de dicha interrupci≤n hacia esta nueva rutina, que visualiza en
pantalla ½una luz╗, y reenlaza despues con la rutina de tratamiento
original.

Seg·n la velocidad de la mßquina en la que se instale, deberß darse un
valor diferente a la constante ½Tiempo╗, por ejemplo, para un 386DX-25
un valor adecuado es 75, y para un 386DX-33 un valor adecuado es 210.
Si eligimos un valor de ½Tiempo╗ demasiado bajo, apenas veremos la
½luz╗ y si se elige uno muiy alto el acceso al disco duro se
ralentiza. Es cuesti≤n de probar el valor ≤ptimo para nuestra
mßquina, teniendo en cuenta que cuanto mayor sea la velocidad del
ordenador, mayor deberß ser el valor que buscamos.

Luis Gasc≤n L≤pez

Valencia


LA FECHA DEL SISTEMA

En ocasiones puede ser ·til la visualizaci≤n de la fecha del dφa, pero
la instrucci≤n ½Time╗ del DOS no es lo mßs adecuado para ello. Este
peque±o programa en C, nos permite la visualizaci≤n de la fecha en su
formato correcto.

#include <stdio.h>

#include <dos.h>

#include <time.h>

void main()

{

 char *day[]={"Domingo",

 "Lunes",

 "Martes",

 "MiΘrcoles",

 "Jueves",

 "Viernes",

 "Sßbado"};

 static char *meses[]={"Enero",

 "Febrero",

 "Marzo",

 "Abril",

 "Mayo",

 "Junio",

 "Julio",

 "Agosto",

 "Septiembre",

 "Octubre",

 "Noviembre",

 "Diciembre",

 };

 time_t time_t;

 struct date date;

 struct tm*tm;

 getdate(&date);

 time_t=dostounix(&date,NULL);

 tm=localtime(&time_t);

 gotoxy(45,2);

 cprintf(" %s ",day[tm-> tm_wday]);

 cprintf("%02d",date.da_day);

 cprintf(" de %s",meses[tm-> tm_mon]);

 cprintf(" de %d\n",date.da_year);

}

Nota de la Laboratorio TΘcnico:

La fecha se visualiza en el estremo superior derecho de la pantalla,
para cambiar esto basta con modificar las coordenadas que aparecen en la
instrucci≤n ½gotoxy╗.

Jose Angel Vidal Gallego

Alacuas. Valencia


CRONOMETRO DE PROGRAMAS

El siguiente programa realizado en C, tiene la utilidad de cronometrar
el tiempo que estß un programa funcionando. Fue mandado por su autor
como una aplicaci≤n para medir el tiempo que empleaba su programa en
escapar del laberento, dentro del concurso de programaci≤n, pero por
su utilidad lo hemos incluido dentro de esta secci≤n.

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

#include <process.h>

#include <time.h>

void main()

{
 char prog[80];

 int r;

 clock_t antes, despues;

 double segs;

 printf( "Programa a cronometrar ? " );

 gets( prog );

 antes = clock();

 r = _spawnlp( _P_WAIT, prog, prog, NULL );

 despues = clock();

 segs = (double)(despues - antes) / CLOCKS_PER_SEC;

 if( r == -1 )

 printf( "\nNo se pudo ejecutar :\n%s" , prog );

 else

 printf( "\n%f segundos tarda en ejecutar :\n%s" , segs , prog );

 exit( r );

}

Joaquφn Obreg≤n Cobo

El Astillero. Cantabria


LA CLAVE DE LAS BIOS AMI

Aunque es una situaci≤n muy poco frecuente, algunos de nuestros
lectores se han encontrado con la desagradable sorpresa de que al
adquirir un ordenador con BIOS AMI (nuevo o de segunda mano) a
personas poco fiables, el setup del mismo se encontraba protegido con
una palabra clave que el vendedor se resistφa a revelar. De esta
forma, algunas empresas se aseguran de que el usuario s≤lo podrß
modificar el hardware de su PC bajo su conocimiento, perdiendo la
garantφa o bien pagando una cantidad extra por la instalaci≤n.

Tanto para este caso extremo como si simplemente se nos olvida nuestra
propia clave, puede resultar de utilidad la siguiente rutina, que
sirve para averiguar la password de las BIOS AMI. Para ello crearemos
en primer lugar un fichero llamado ½crackami.dbg╗ con el siguiente
contenido:

a

jmp 118

db 37

mov al,[102]

out 70,al

jmp 10a

inc byte ptr [102]

cmp byte ptr [102],3f

je 13f

in al,71

ret

call 103

and al,f0

mov ah,al

call 103

or al,al

jz 13f

push ax

xor cl,cl

cmp al,ah

je 138

test al,e1

jpe 132

stc

rcl al,1

inc cl

jnz 129

mov al,cl

int 29

pop ax

jmp 11d

xor al,al

ret

db '// 1.1 // ARM '

<lφnea en blanco>

rcx

50

n crackami.com

w

q

<lφnea en blanco>

A continuaci≤n damos la orden ½DEBUG <crackami.dbg╗ para generar el
fichero ejecutable. Al lanzar el programa ½CRACKAMI.COM╗ asφ creado
se imprimirß en pantalla la palabra clave almacenada actualmente en la
memoria CMOS de nuestro ordenador.

Antes de finalizar, hemos de hacer dos serias advertencias. La
primera es que AMI ha modificado el mΘtodo de encriptaci≤n de la clave
en sus BIOS mßs recientes, las de 1994 (y en algunas del 93), de modo
que en estos casos no funcionarß la presente rutina. La segunda y mßs
importante es que este programa s≤lo puede ser utilizado con el propio
ordenador: es un delito emplearlo en otra mßquina sin autorizaci≤n
expresa de su due±o, con el fin de tener acceso a la informaci≤n
almacenada.

Arturo Ramφrez-Montesinos Krogulski

Boadilla del Monte (Madrid)

Nota: Si el programa es incapaz de averiguar la clave almacenada en
la CMOS, habremos de recurrir a un mΘtodo ½artesanal╗. Para ello
llevaremos a cabo lo que se conoce como cortocircuitar la placa base,
uniendo mediante un cable las dos patillas de la baterφa de la CMOS.
Esto tiene como efecto inmediato la descarga total de todos los datos
almacenados en la propia CMOS (parßmetros de disco duro, memoria y
disqueteras incluidas). En ciertas placas base basta con variar la
posici≤n de un jumper para llevar a cabo esta descarga.


CALLAR A LA SOUND BLASTER

Este truco estß dirigido a quienes posean una Sound Blaster y cuyo
sonido hubieran deseado anular en alguna ocasi≤n sin tener que
recurrir al potenci≤metro del amplificador. La siguiente rutina,
escrita en Borland C++ 2.0, permite reducir el volumen de dicha
tarjeta usando la tecla Scroll Lock (o Bloq Despl).

El funcionamiento del programa es muy sencillo. En primer lugar se
accede al chip del mezclador (puerto 224h) y se selecciona el registro
n·mero 3, que es el que controla el volumen de los dos altavoces de la
Sound Blaster. Luego, mediante el puerto de datos del chip, se reduce
el volumen hasta cero o hasta ½Ah╗ (este valor se puede cambiar a
gusto del usuario) seg·n el estado de la tecla Bloq Despl. Tras ello
se deja el programa residente en memoria.

El puerto base de la Sound Blaster que se utiliza en este programa es
el 220h. Pero hay algunas tarjetas que utilizan el puerto 240h. En
este caso, se deberß modificar el valor de la variable ½BASE╗.

#include "dos.h"

void interrupt (*oldkbd)();

void interrupt handler();

void interrupt handler()

{

 int tecla

 unsigned int BASE = 0x220;

 //Puerto base por defecto de la SB

 unsigned int CHIPBASE = BASE + 4;

 tecla = peek (0x0040, 0x0017);

 // Lee el estado del teclado

 if (tecla & 16)

 // Si la tecla Bloq Despl estß encendida

 {

 asm {

 mov dx, CHIP

 // Puerto de registros del chip mezclador

 mov al, 3 // Volumen Master

 out dx, al // Seleccionar registro

 inc dx

 xor al, al // Reduce volumen

 out dx, al

 }

 }

 Else

 // Si estß apagada...

 {

 asm {

 mov dx, CHIP

 mov al, 3

 out dx, al

 inc dx // Puerto de datos del chip mezclador

 xor al, 0ah // Aumento el volumen

 out dx, al

 }

 }

 oldkbd (); // Llamo a la antigua interrupci≤n

}

void main (int argc, char **argv)

{

 oldkbd=getvect(0x9);

 setvect(0x9, handler);

 printf("\nSound Blaster PRO Volume");

 printf("\n========================");

 printf("\n Programa en memoria.");

 printf("\n========================\n");

 keep(0, (_SS+(_SP/16)- _psp)); //Instala el programa

}


Eduard Sßnchez Palaz≤n

Terrassa (Barcelona)


El UTIL XCOPY

Muchas veces se nos ha presentado el problema de tener que copiar del
disco duro a una unidad de disquete, sobrepasando con lo que deseamos
copiar el espacio del disco, teniendo que recurrir a varios disquetes
y efectuar la copia fichero a fichero para evitar la tan temida frase
de ½espacio insuficiente╗.

Para remediar este problema, el mismo sistema operativo nos ofrece una
soluci≤n:

Primero ponemos el atributo de archivo a todos los ficheros que
deseemos copiar a disquete:

Por ejemplo: ½Attrib c:\graficos\*.* +A╗

Si queremos copiar tambiΘn los subdirectorios podemos a±adir el
parßmetro /s

Introducir el disco en la unidad destino y escribir la orden de copia.
Por ejemplo:

½xcopy c:\graficos\*.* /m╗

Con el parßmetro /m conseguimos que se vaya modificando el atributo de
archivo segun se copian los diferentes ficheros.

Ejecutaremos este ·ltimo paso y el ordenador empezarß a copiar hasta
que no haya mßs espacio en el disco destino; entonces mostrarß el
mensaje de ½espacio insuficiente en disco╗ en cuyo caso sustituiremos
el disquete y repetiremos de nuevo el ·ltimo paso, con lo que
continuarß copiando en el archivo en que se qued≤. Si repetimos este
paso cuantas veces sea necesario habremos copiado todos los ficheros
que deseabamos.

Joaquφn Dionisio Sßnchez

Mßlaga


INTERRUPCIONES CON QUICKBASIC

El uso de interrupciones a la hora de realizar cualquier programa es
una buena tΘcnica para aumentar el grado de profesionalidad en Θstos,
ya que asφ podremos emplear servicios de la ROM-BIOS y del DOS tales
como incluir soporte para rat≤n, controlar el subsistema grßfico, etc.

Como sabΘis, el uso de interrupciones resulta mßs fßcil de llevar a la
prßctica en unos lenguajes que en otros, aunque no siempre se deba a
limitaciones del propio lenguaje. En el caso de QuickBasic 4.5 parece
que la causa reside mßs bien en la falta de documentaci≤n acerca de
c≤mo acceder a este tipo de servicios.

Desde tierras levantinas nos ha llegado la soluci≤n al problema, de
modo que quienes deseen utilizar las interrupciones en sus programas
simplemente tendrßn que seguir los pasos que a continuaci≤n
describimos. En primer lugar, hay que crear un archivo ASCII, llamado
½intxs.bi╗, con el siguiente contenido:

TYPE tReg

 ax AS INTEGER

 bx AS INTEGER

 cx AS INTEGER

 dx AS INTEGER

 bp AS INTEGER

 si AS INTEGER

 di AS INTEGER

 flags AS INTEGER

 ds AS INTEGER

 es AS INTEGER

END TYPE

DIM SHARED rEn AS tReg

DIM SHARED rFue AS tReg

DECLARE SUB INTERRUPTX(num AS INTEGER, rEn AS tReg, rFue AS tReg)

A continuaci≤n, iniciaremos QuickBasic con el parßmetro ½/l╗ (por
ejemplo, ½C:\QB45\QB /l╗).

Al principio del programa en el que queramos acceder a alguna
interrupci≤n a±adiremos la orden ½$INCLUDE: 'intxs.bi'╗. (El archivo
½intxs.bi╗ debe estar en el subdirectorio donde estΘ el QuickBasic).

Para realizar una interrupci≤n desde cualquier punto del programa
basta con ejecutar la orden ½CALL INTERRUPTX(num, rEn, rFue)╗, siendo
½num╗ el n·mero del servicio que queremos usar.

Por lo general, tendremos que ½pasar╗ unos parßmetros para indicar quΘ
funci≤n queremos usar del servicio y otros datos. En ciertas
ocasiones tambiΘn serß necesario obtener el resultado de la llamada al
servicio. Los parßmetros de entrada se tienen que dejar en la
variable ½rEn╗, mientras que los de salida se obtienen o recogen en
½rFue╗.

A continuaci≤n presentamos un esquema general:


rem parßmetros de entrada (si son necesarios)

rEn.ax = &Hxxxx

rEn.bx = &Hyyyy

rEn.cx = &Hzzzz

rem llamada al servicio

CALL INTERRUPTX(&Hxx,rEn,rFue)

rem evaluaci≤n de la salida (si es necesario)

IF rFue.ax=nn THEN <acciones>

PRINT rFue.bx


Hay que se±alar que el mΘtodo tiene el inconveniente de la
imposibilidad de separar los registros AX, BX, CX y DX en sus bytes
respectivos (AH, AL; BH, BL;...), por lo que nos veremos obligados a
trabajar con el registro entero. TambiΘn hay que advertir que la
forma mßs c≤moda de trabajar es en hexadecimal.

Veamos a continuaci≤n c≤mo utilizarlo. Supongamos que tenemos que
pasar al servicio los siguientes parßmetros de entrada: ½AL = x╗ y
½AH = y╗.

En primer lugar convertimos ½x╗ e ½y╗ a hexadecimal:

½x╗ lo convertimos en &Hmm, e ½y╗ lo convertimos &Hnn

(de forma que ½mm╗ y ½nn╗ sean de 2 dφgitos, rellenando con un ½0╗ por
la izquierda si es necesario).

Los parßmetros de entrada serßn ½rEn = &Hnnmm╗.

Si alg·n byte no hay que usarlo lo llenamos con ½00╗. Es decir, si
por ejemplo tenemos que pasarle en BL el valor 10, la instrucci≤n serß
½rEn.bx=&H000A╗.

De igual forma, a la hora de obtener los resultados en ½rFue╗ habrß
que separar en AH, AL; BH, BL; ... El procedimiento para ello es el
siguiente: convertimos el registro a separar (por ejemplo BX) a
hexadecimal; obtendremos entonces 4 dφgitos (si son menos se rellena
por la izquierda con ½0╗ hasta que sean 4). Los dos primeros, por la
derecha, corresponderßn a BH y los dos siguientes a BL. Una vez
separados los podemos transformar a su vez en decimal o binario seg·n
nuestras necesidades.

Sergio Ballester Lorente

Godella. (Valencia)


ALARMA RESIDENTE

Delante del ordenador las horas pasan muy rßpidamente y por eso
es aconsejable disponer de un reloj con alarma a mano. íQuΘ mejor
reloj que el interno del ordenador! Este programa es una alarma que
avisarß de la hora indicada con unos pitidos. Se queda residente y
emplea muy poca memoria para ello. Estß realizado en ensamblador y
podemos emplear el ½debug╗ para compilarlo.

a

mov ax,2528

mov dx,0117

int 21

mov ah,49

mov es,[2c]

int 21

mov ah,31

mov dx,14

int 21

nop

nop

push ax

push bx

push cx

push dx

mov ah,02

int 1a

cmp ch,05 ;Horas

jne 139

cmp cl,05 ;minutos

jne 139

cmp dh,02 ;segundos

jne 139

mov cx,04

mov al,07

mov ah,0e

int 10

pop dx

pop cx

pop bx

pop ax

iret

<Lφnea en blanco>

rcx

3e

n alarma.com

w

q


Gontzal Uriarte G≤mez

San Juan (Alicante)


FICHEROS ½BATCH╗

Muchos usuarios habrßn necesitado en mßs de una ocasi≤n que un fichero
batch envφe su salida a la impresora o a un fichero de texto, y
l≤gicamente habrßn hecho lo siguiente:

Fbatch > Salida.prn

Suponiendo que el fichero se llama ½Fbatch.bat╗ y se desea volcar la
salida al fichero ½Salida.prn╗.

Pero el funcionamiento interno del DOS no lo permite (al contrario que
en otros sistemas operativos como Unix), ya que s≤lo se redirecciona
la salida de programas ½.COM╗ o ½.EXE╗ que utilicen la salida
estßndar.

La soluci≤n estß en emular el comportamiento de sistemas operativos
como el Unix. Veamos quΘ hace el Unix cuando lanza un fichero script
(batch para MS-DOS). Lo primero que hace es cargar un nuevo shell que
ejecute los comandos del fichero y redireccionar la salida donde se
haya especificado o a la consola por defecto. Pues bien, esto
traducido en MS-DOS serφa:

Command /C Fbatch > Salida.prn

En realidad se le estß diciendo que se cargue un nuevo shell
(½command.com╗) y se redireccione la salida estßndar de Θste al
fichero ½Salida.prn╗, pero que ·nicamente se ejecuten los comandos que
hay en ½Fbatch.bat╗ y regrese al shell anterior (parßmetro /C).

Gabriel Martφ

Barcelona